/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using MaxWindow7Stride4Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Max, pooling::Forward>;
TYPED_TEST_SUITE(MaxWindow7Stride4Forward, GTestTypePairs);
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x11x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {49., 53.,  55.,  93., 97.,
                                         99., 115., 119., 121.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x11x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73., 77., 117., 121.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x11x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {97.,  98.,  105., 106., 109., 110.,
                                         185., 186., 193., 194., 197., 198.,
                                         229., 230., 237., 238., 241., 242.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x11x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {145., 146., 153., 154.,
                                         233., 234., 241., 242.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x11x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193., 194., 195., 196., 209., 210., 211., 212., 217., 218., 219., 220.,
      369., 370., 371., 372., 385., 386., 387., 388., 393., 394., 395., 396.,
      457., 458., 459., 460., 473., 474., 475., 476., 481., 482., 483., 484.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x11x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {289., 290., 291., 292., 305., 306.,
                                         307., 308., 465., 466., 467., 468.,
                                         481., 482., 483., 484.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x11x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {54.,  58.,  60.,  102., 106.,
                                         108., 126., 130., 132.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x11x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {79., 83., 127., 131.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x11x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {107., 108., 115., 116., 119., 120.,
                                         203., 204., 211., 212., 215., 216.,
                                         251., 252., 259., 260., 263., 264.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x11x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {157., 158., 165., 166.,
                                         253., 254., 261., 262.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x11x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      213., 214., 215., 216., 229., 230., 231., 232., 237., 238., 239., 240.,
      405., 406., 407., 408., 421., 422., 423., 424., 429., 430., 431., 432.,
      501., 502., 503., 504., 517., 518., 519., 520., 525., 526., 527., 528.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x11x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {313., 314., 315., 316., 329., 330.,
                                         331., 332., 505., 506., 507., 508.,
                                         521., 522., 523., 524.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x11x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61.,  65.,  69.,  70.,  117., 121.,
                                         125., 126., 145., 149., 153., 154.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x11x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91., 95., 147., 151.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x11x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 129., 130., 137., 138., 139., 140., 233., 234., 241., 242.,
      249., 250., 251., 252., 289., 290., 297., 298., 305., 306., 307., 308.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x11x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {181., 182., 189., 190.,
                                         293., 294., 301., 302.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x11x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241., 242., 243., 244., 257., 258., 259., 260., 273., 274., 275., 276.,
      277., 278., 279., 280., 465., 466., 467., 468., 481., 482., 483., 484.,
      497., 498., 499., 500., 501., 502., 503., 504., 577., 578., 579., 580.,
      593., 594., 595., 596., 609., 610., 611., 612., 613., 614., 615., 616.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x11x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {361., 362., 363., 364., 377., 378.,
                                         379., 380., 585., 586., 587., 588.,
                                         601., 602., 603., 604.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x12x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60.,  64.,  66.,  104., 108.,
                                         110., 126., 130., 132.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x12x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73., 77., 117., 121.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x12x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {119., 120., 127., 128., 131., 132.,
                                         207., 208., 215., 216., 219., 220.,
                                         251., 252., 259., 260., 263., 264.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x12x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {145., 146., 153., 154.,
                                         233., 234., 241., 242.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x12x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237., 238., 239., 240., 253., 254., 255., 256., 261., 262., 263., 264.,
      413., 414., 415., 416., 429., 430., 431., 432., 437., 438., 439., 440.,
      501., 502., 503., 504., 517., 518., 519., 520., 525., 526., 527., 528.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x12x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {289., 290., 291., 292., 305., 306.,
                                         307., 308., 465., 466., 467., 468.,
                                         481., 482., 483., 484.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x12x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {66.,  70.,  72.,  114., 118.,
                                         120., 138., 142., 144.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x12x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {79., 83., 127., 131.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x12x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {131., 132., 139., 140., 143., 144.,
                                         227., 228., 235., 236., 239., 240.,
                                         275., 276., 283., 284., 287., 288.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x12x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {157., 158., 165., 166.,
                                         253., 254., 261., 262.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x12x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      261., 262., 263., 264., 277., 278., 279., 280., 285., 286., 287., 288.,
      453., 454., 455., 456., 469., 470., 471., 472., 477., 478., 479., 480.,
      549., 550., 551., 552., 565., 566., 567., 568., 573., 574., 575., 576.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x12x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {313., 314., 315., 316., 329., 330.,
                                         331., 332., 505., 506., 507., 508.,
                                         521., 522., 523., 524.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x12x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {75.,  79.,  83.,  84.,  131., 135.,
                                         139., 140., 159., 163., 167., 168.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x12x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91., 95., 147., 151.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x12x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149., 150., 157., 158., 165., 166., 167., 168., 261., 262., 269., 270.,
      277., 278., 279., 280., 317., 318., 325., 326., 333., 334., 335., 336.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x12x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {181., 182., 189., 190.,
                                         293., 294., 301., 302.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x12x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      297., 298., 299., 300., 313., 314., 315., 316., 329., 330., 331., 332.,
      333., 334., 335., 336., 521., 522., 523., 524., 537., 538., 539., 540.,
      553., 554., 555., 556., 557., 558., 559., 560., 633., 634., 635., 636.,
      649., 650., 651., 652., 665., 666., 667., 668., 669., 670., 671., 672.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x12x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {361., 362., 363., 364., 377., 378.,
                                         379., 380., 585., 586., 587., 588.,
                                         601., 602., 603., 604.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x14x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {49.,  53.,  55.,  93.,  97.,  99.,
                                         137., 141., 143., 148., 152., 154.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x14x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73., 77., 117., 121.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x14x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  98.,  105., 106., 109., 110., 185., 186., 193., 194., 197., 198.,
      273., 274., 281., 282., 285., 286., 295., 296., 303., 304., 307., 308.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x14x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {145., 146., 153., 154.,
                                         233., 234., 241., 242.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x14x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193., 194., 195., 196., 209., 210., 211., 212., 217., 218., 219., 220.,
      369., 370., 371., 372., 385., 386., 387., 388., 393., 394., 395., 396.,
      545., 546., 547., 548., 561., 562., 563., 564., 569., 570., 571., 572.,
      589., 590., 591., 592., 605., 606., 607., 608., 613., 614., 615., 616.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x14x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {289., 290., 291., 292., 305., 306.,
                                         307., 308., 465., 466., 467., 468.,
                                         481., 482., 483., 484.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x14x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {54.,  58.,  60.,  102., 106., 108.,
                                         150., 154., 156., 162., 166., 168.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x14x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {79., 83., 127., 131.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x14x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107., 108., 115., 116., 119., 120., 203., 204., 211., 212., 215., 216.,
      299., 300., 307., 308., 311., 312., 323., 324., 331., 332., 335., 336.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x14x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {157., 158., 165., 166.,
                                         253., 254., 261., 262.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x14x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      213., 214., 215., 216., 229., 230., 231., 232., 237., 238., 239., 240.,
      405., 406., 407., 408., 421., 422., 423., 424., 429., 430., 431., 432.,
      597., 598., 599., 600., 613., 614., 615., 616., 621., 622., 623., 624.,
      645., 646., 647., 648., 661., 662., 663., 664., 669., 670., 671., 672.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x14x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {313., 314., 315., 316., 329., 330.,
                                         331., 332., 505., 506., 507., 508.,
                                         521., 522., 523., 524.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x14x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {61.,  65.,  69.,  70.,  117., 121.,
                                         125., 126., 173., 177., 181., 182.,
                                         187., 191., 195., 196.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x14x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91., 95., 147., 151.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x14x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 129., 130., 137., 138., 139., 140., 233., 234., 241.,
      242., 249., 250., 251., 252., 345., 346., 353., 354., 361., 362.,
      363., 364., 373., 374., 381., 382., 389., 390., 391., 392.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x14x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {181., 182., 189., 190.,
                                         293., 294., 301., 302.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME1x14x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241., 242., 243., 244., 257., 258., 259., 260., 273., 274., 275.,
      276., 277., 278., 279., 280., 465., 466., 467., 468., 481., 482.,
      483., 484., 497., 498., 499., 500., 501., 502., 503., 504., 689.,
      690., 691., 692., 705., 706., 707., 708., 721., 722., 723., 724.,
      725., 726., 727., 728., 745., 746., 747., 748., 761., 762., 763.,
      764., 777., 778., 779., 780., 781., 782., 783., 784.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID1x14x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {361., 362., 363., 364., 377., 378.,
                                         379., 380., 585., 586., 587., 588.,
                                         601., 602., 603., 604.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x11x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  53.,  55.,  93.,  97.,  99.,  115., 119., 121.,
      170., 174., 176., 214., 218., 220., 236., 240., 242.,
      291., 295., 297., 335., 339., 341., 357., 361., 363.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x11x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  77.,  117., 121., 194., 198.,
                                         238., 242., 315., 319., 359., 363.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x11x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  98.,  105., 106., 109., 110., 185., 186., 193., 194., 197.,
      198., 229., 230., 237., 238., 241., 242., 339., 340., 347., 348.,
      351., 352., 427., 428., 435., 436., 439., 440., 471., 472., 479.,
      480., 483., 484., 581., 582., 589., 590., 593., 594., 669., 670.,
      677., 678., 681., 682., 713., 714., 721., 722., 725., 726.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x11x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 153., 154., 233., 234., 241., 242., 387., 388., 395., 396.,
      475., 476., 483., 484., 629., 630., 637., 638., 717., 718., 725., 726.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x11x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193.,  194.,  195.,  196.,  209.,  210.,  211.,  212.,  217.,  218.,
      219.,  220.,  369.,  370.,  371.,  372.,  385.,  386.,  387.,  388.,
      393.,  394.,  395.,  396.,  457.,  458.,  459.,  460.,  473.,  474.,
      475.,  476.,  481.,  482.,  483.,  484.,  677.,  678.,  679.,  680.,
      693.,  694.,  695.,  696.,  701.,  702.,  703.,  704.,  853.,  854.,
      855.,  856.,  869.,  870.,  871.,  872.,  877.,  878.,  879.,  880.,
      941.,  942.,  943.,  944.,  957.,  958.,  959.,  960.,  965.,  966.,
      967.,  968.,  1161., 1162., 1163., 1164., 1177., 1178., 1179., 1180.,
      1185., 1186., 1187., 1188., 1337., 1338., 1339., 1340., 1353., 1354.,
      1355., 1356., 1361., 1362., 1363., 1364., 1425., 1426., 1427., 1428.,
      1441., 1442., 1443., 1444., 1449., 1450., 1451., 1452.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x11x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      289.,  290.,  291.,  292.,  305.,  306.,  307.,  308.,  465.,  466.,
      467.,  468.,  481.,  482.,  483.,  484.,  773.,  774.,  775.,  776.,
      789.,  790.,  791.,  792.,  949.,  950.,  951.,  952.,  965.,  966.,
      967.,  968.,  1257., 1258., 1259., 1260., 1273., 1274., 1275., 1276.,
      1433., 1434., 1435., 1436., 1449., 1450., 1451., 1452.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x11x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54.,  58.,  60.,  102., 106., 108., 126., 130., 132.,
      186., 190., 192., 234., 238., 240., 258., 262., 264.,
      318., 322., 324., 366., 370., 372., 390., 394., 396.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x11x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {79.,  83.,  127., 131., 211., 215.,
                                         259., 263., 343., 347., 391., 395.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x11x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107., 108., 115., 116., 119., 120., 203., 204., 211., 212., 215.,
      216., 251., 252., 259., 260., 263., 264., 371., 372., 379., 380.,
      383., 384., 467., 468., 475., 476., 479., 480., 515., 516., 523.,
      524., 527., 528., 635., 636., 643., 644., 647., 648., 731., 732.,
      739., 740., 743., 744., 779., 780., 787., 788., 791., 792.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x11x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      157., 158., 165., 166., 253., 254., 261., 262., 421., 422., 429., 430.,
      517., 518., 525., 526., 685., 686., 693., 694., 781., 782., 789., 790.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x11x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      213.,  214.,  215.,  216.,  229.,  230.,  231.,  232.,  237.,  238.,
      239.,  240.,  405.,  406.,  407.,  408.,  421.,  422.,  423.,  424.,
      429.,  430.,  431.,  432.,  501.,  502.,  503.,  504.,  517.,  518.,
      519.,  520.,  525.,  526.,  527.,  528.,  741.,  742.,  743.,  744.,
      757.,  758.,  759.,  760.,  765.,  766.,  767.,  768.,  933.,  934.,
      935.,  936.,  949.,  950.,  951.,  952.,  957.,  958.,  959.,  960.,
      1029., 1030., 1031., 1032., 1045., 1046., 1047., 1048., 1053., 1054.,
      1055., 1056., 1269., 1270., 1271., 1272., 1285., 1286., 1287., 1288.,
      1293., 1294., 1295., 1296., 1461., 1462., 1463., 1464., 1477., 1478.,
      1479., 1480., 1485., 1486., 1487., 1488., 1557., 1558., 1559., 1560.,
      1573., 1574., 1575., 1576., 1581., 1582., 1583., 1584.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x11x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      313.,  314.,  315.,  316.,  329.,  330.,  331.,  332.,  505.,  506.,
      507.,  508.,  521.,  522.,  523.,  524.,  841.,  842.,  843.,  844.,
      857.,  858.,  859.,  860.,  1033., 1034., 1035., 1036., 1049., 1050.,
      1051., 1052., 1369., 1370., 1371., 1372., 1385., 1386., 1387., 1388.,
      1561., 1562., 1563., 1564., 1577., 1578., 1579., 1580.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x11x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  65.,  69.,  70.,  117., 121., 125., 126., 145., 149., 153., 154.,
      215., 219., 223., 224., 271., 275., 279., 280., 299., 303., 307., 308.,
      369., 373., 377., 378., 425., 429., 433., 434., 453., 457., 461., 462.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x11x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.,  95.,  147., 151., 245., 249.,
                                         301., 305., 399., 403., 455., 459.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x11x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121., 122., 129., 130., 137., 138., 139., 140., 233., 234., 241., 242.,
      249., 250., 251., 252., 289., 290., 297., 298., 305., 306., 307., 308.,
      429., 430., 437., 438., 445., 446., 447., 448., 541., 542., 549., 550.,
      557., 558., 559., 560., 597., 598., 605., 606., 613., 614., 615., 616.,
      737., 738., 745., 746., 753., 754., 755., 756., 849., 850., 857., 858.,
      865., 866., 867., 868., 905., 906., 913., 914., 921., 922., 923., 924.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x11x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      181., 182., 189., 190., 293., 294., 301., 302., 489., 490., 497., 498.,
      601., 602., 609., 610., 797., 798., 805., 806., 909., 910., 917., 918.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x11x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241.,  242.,  243.,  244.,  257.,  258.,  259.,  260.,  273.,  274.,
      275.,  276.,  277.,  278.,  279.,  280.,  465.,  466.,  467.,  468.,
      481.,  482.,  483.,  484.,  497.,  498.,  499.,  500.,  501.,  502.,
      503.,  504.,  577.,  578.,  579.,  580.,  593.,  594.,  595.,  596.,
      609.,  610.,  611.,  612.,  613.,  614.,  615.,  616.,  857.,  858.,
      859.,  860.,  873.,  874.,  875.,  876.,  889.,  890.,  891.,  892.,
      893.,  894.,  895.,  896.,  1081., 1082., 1083., 1084., 1097., 1098.,
      1099., 1100., 1113., 1114., 1115., 1116., 1117., 1118., 1119., 1120.,
      1193., 1194., 1195., 1196., 1209., 1210., 1211., 1212., 1225., 1226.,
      1227., 1228., 1229., 1230., 1231., 1232., 1473., 1474., 1475., 1476.,
      1489., 1490., 1491., 1492., 1505., 1506., 1507., 1508., 1509., 1510.,
      1511., 1512., 1697., 1698., 1699., 1700., 1713., 1714., 1715., 1716.,
      1729., 1730., 1731., 1732., 1733., 1734., 1735., 1736., 1809., 1810.,
      1811., 1812., 1825., 1826., 1827., 1828., 1841., 1842., 1843., 1844.,
      1845., 1846., 1847., 1848.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x11x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      361.,  362.,  363.,  364.,  377.,  378.,  379.,  380.,  585.,  586.,
      587.,  588.,  601.,  602.,  603.,  604.,  977.,  978.,  979.,  980.,
      993.,  994.,  995.,  996.,  1201., 1202., 1203., 1204., 1217., 1218.,
      1219., 1220., 1593., 1594., 1595., 1596., 1609., 1610., 1611., 1612.,
      1817., 1818., 1819., 1820., 1833., 1834., 1835., 1836.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x12x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60.,  64.,  66.,  104., 108., 110., 126., 130., 132.,
      192., 196., 198., 236., 240., 242., 258., 262., 264.,
      324., 328., 330., 368., 372., 374., 390., 394., 396.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x12x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  77.,  117., 121., 205., 209.,
                                         249., 253., 337., 341., 381., 385.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x12x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119., 120., 127., 128., 131., 132., 207., 208., 215., 216., 219.,
      220., 251., 252., 259., 260., 263., 264., 383., 384., 391., 392.,
      395., 396., 471., 472., 479., 480., 483., 484., 515., 516., 523.,
      524., 527., 528., 647., 648., 655., 656., 659., 660., 735., 736.,
      743., 744., 747., 748., 779., 780., 787., 788., 791., 792.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x12x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 153., 154., 233., 234., 241., 242., 409., 410., 417., 418.,
      497., 498., 505., 506., 673., 674., 681., 682., 761., 762., 769., 770.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x12x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237.,  238.,  239.,  240.,  253.,  254.,  255.,  256.,  261.,  262.,
      263.,  264.,  413.,  414.,  415.,  416.,  429.,  430.,  431.,  432.,
      437.,  438.,  439.,  440.,  501.,  502.,  503.,  504.,  517.,  518.,
      519.,  520.,  525.,  526.,  527.,  528.,  765.,  766.,  767.,  768.,
      781.,  782.,  783.,  784.,  789.,  790.,  791.,  792.,  941.,  942.,
      943.,  944.,  957.,  958.,  959.,  960.,  965.,  966.,  967.,  968.,
      1029., 1030., 1031., 1032., 1045., 1046., 1047., 1048., 1053., 1054.,
      1055., 1056., 1293., 1294., 1295., 1296., 1309., 1310., 1311., 1312.,
      1317., 1318., 1319., 1320., 1469., 1470., 1471., 1472., 1485., 1486.,
      1487., 1488., 1493., 1494., 1495., 1496., 1557., 1558., 1559., 1560.,
      1573., 1574., 1575., 1576., 1581., 1582., 1583., 1584.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x12x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      289.,  290.,  291.,  292.,  305.,  306.,  307.,  308.,  465.,  466.,
      467.,  468.,  481.,  482.,  483.,  484.,  817.,  818.,  819.,  820.,
      833.,  834.,  835.,  836.,  993.,  994.,  995.,  996.,  1009., 1010.,
      1011., 1012., 1345., 1346., 1347., 1348., 1361., 1362., 1363., 1364.,
      1521., 1522., 1523., 1524., 1537., 1538., 1539., 1540.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x12x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      66.,  70.,  72.,  114., 118., 120., 138., 142., 144.,
      210., 214., 216., 258., 262., 264., 282., 286., 288.,
      354., 358., 360., 402., 406., 408., 426., 430., 432.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x12x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {79.,  83.,  127., 131., 223., 227.,
                                         271., 275., 367., 371., 415., 419.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x12x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      131., 132., 139., 140., 143., 144., 227., 228., 235., 236., 239.,
      240., 275., 276., 283., 284., 287., 288., 419., 420., 427., 428.,
      431., 432., 515., 516., 523., 524., 527., 528., 563., 564., 571.,
      572., 575., 576., 707., 708., 715., 716., 719., 720., 803., 804.,
      811., 812., 815., 816., 851., 852., 859., 860., 863., 864.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x12x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      157., 158., 165., 166., 253., 254., 261., 262., 445., 446., 453., 454.,
      541., 542., 549., 550., 733., 734., 741., 742., 829., 830., 837., 838.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x12x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      261.,  262.,  263.,  264.,  277.,  278.,  279.,  280.,  285.,  286.,
      287.,  288.,  453.,  454.,  455.,  456.,  469.,  470.,  471.,  472.,
      477.,  478.,  479.,  480.,  549.,  550.,  551.,  552.,  565.,  566.,
      567.,  568.,  573.,  574.,  575.,  576.,  837.,  838.,  839.,  840.,
      853.,  854.,  855.,  856.,  861.,  862.,  863.,  864.,  1029., 1030.,
      1031., 1032., 1045., 1046., 1047., 1048., 1053., 1054., 1055., 1056.,
      1125., 1126., 1127., 1128., 1141., 1142., 1143., 1144., 1149., 1150.,
      1151., 1152., 1413., 1414., 1415., 1416., 1429., 1430., 1431., 1432.,
      1437., 1438., 1439., 1440., 1605., 1606., 1607., 1608., 1621., 1622.,
      1623., 1624., 1629., 1630., 1631., 1632., 1701., 1702., 1703., 1704.,
      1717., 1718., 1719., 1720., 1725., 1726., 1727., 1728.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x12x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      313.,  314.,  315.,  316.,  329.,  330.,  331.,  332.,  505.,  506.,
      507.,  508.,  521.,  522.,  523.,  524.,  889.,  890.,  891.,  892.,
      905.,  906.,  907.,  908.,  1081., 1082., 1083., 1084., 1097., 1098.,
      1099., 1100., 1465., 1466., 1467., 1468., 1481., 1482., 1483., 1484.,
      1657., 1658., 1659., 1660., 1673., 1674., 1675., 1676.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x12x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      75.,  79.,  83.,  84.,  131., 135., 139., 140., 159., 163., 167., 168.,
      243., 247., 251., 252., 299., 303., 307., 308., 327., 331., 335., 336.,
      411., 415., 419., 420., 467., 471., 475., 476., 495., 499., 503., 504.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x12x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.,  95.,  147., 151., 259., 263.,
                                         315., 319., 427., 431., 483., 487.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x12x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149., 150., 157.,  158.,  165.,  166., 167., 168., 261., 262., 269.,
      270., 277., 278.,  279.,  280.,  317., 318., 325., 326., 333., 334.,
      335., 336., 485.,  486.,  493.,  494., 501., 502., 503., 504., 597.,
      598., 605., 606.,  613.,  614.,  615., 616., 653., 654., 661., 662.,
      669., 670., 671.,  672.,  821.,  822., 829., 830., 837., 838., 839.,
      840., 933., 934.,  941.,  942.,  949., 950., 951., 952., 989., 990.,
      997., 998., 1005., 1006., 1007., 1008.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x12x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      181., 182., 189., 190., 293., 294., 301., 302., 517., 518., 525., 526.,
      629., 630., 637., 638., 853., 854., 861., 862., 965., 966., 973., 974.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x12x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      297.,  298.,  299.,  300.,  313.,  314.,  315.,  316.,  329.,  330.,
      331.,  332.,  333.,  334.,  335.,  336.,  521.,  522.,  523.,  524.,
      537.,  538.,  539.,  540.,  553.,  554.,  555.,  556.,  557.,  558.,
      559.,  560.,  633.,  634.,  635.,  636.,  649.,  650.,  651.,  652.,
      665.,  666.,  667.,  668.,  669.,  670.,  671.,  672.,  969.,  970.,
      971.,  972.,  985.,  986.,  987.,  988.,  1001., 1002., 1003., 1004.,
      1005., 1006., 1007., 1008., 1193., 1194., 1195., 1196., 1209., 1210.,
      1211., 1212., 1225., 1226., 1227., 1228., 1229., 1230., 1231., 1232.,
      1305., 1306., 1307., 1308., 1321., 1322., 1323., 1324., 1337., 1338.,
      1339., 1340., 1341., 1342., 1343., 1344., 1641., 1642., 1643., 1644.,
      1657., 1658., 1659., 1660., 1673., 1674., 1675., 1676., 1677., 1678.,
      1679., 1680., 1865., 1866., 1867., 1868., 1881., 1882., 1883., 1884.,
      1897., 1898., 1899., 1900., 1901., 1902., 1903., 1904., 1977., 1978.,
      1979., 1980., 1993., 1994., 1995., 1996., 2009., 2010., 2011., 2012.,
      2013., 2014., 2015., 2016.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x12x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      361.,  362.,  363.,  364.,  377.,  378.,  379.,  380.,  585.,  586.,
      587.,  588.,  601.,  602.,  603.,  604.,  1033., 1034., 1035., 1036.,
      1049., 1050., 1051., 1052., 1257., 1258., 1259., 1260., 1273., 1274.,
      1275., 1276., 1705., 1706., 1707., 1708., 1721., 1722., 1723., 1724.,
      1929., 1930., 1931., 1932., 1945., 1946., 1947., 1948.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x14x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  53.,  55.,  93.,  97.,  99.,  137., 141., 143., 148., 152., 154.,
      203., 207., 209., 247., 251., 253., 291., 295., 297., 302., 306., 308.,
      357., 361., 363., 401., 405., 407., 445., 449., 451., 456., 460., 462.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x14x11x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  77.,  117., 121., 227., 231.,
                                         271., 275., 381., 385., 425., 429.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x14x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      97.,  98.,  105., 106., 109., 110., 185., 186., 193., 194., 197., 198.,
      273., 274., 281., 282., 285., 286., 295., 296., 303., 304., 307., 308.,
      405., 406., 413., 414., 417., 418., 493., 494., 501., 502., 505., 506.,
      581., 582., 589., 590., 593., 594., 603., 604., 611., 612., 615., 616.,
      713., 714., 721., 722., 725., 726., 801., 802., 809., 810., 813., 814.,
      889., 890., 897., 898., 901., 902., 911., 912., 919., 920., 923., 924.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x14x11x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 153., 154., 233., 234., 241., 242., 453., 454., 461., 462.,
      541., 542., 549., 550., 761., 762., 769., 770., 849., 850., 857., 858.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x14x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193.,  194.,  195.,  196.,  209.,  210.,  211.,  212.,  217.,  218.,
      219.,  220.,  369.,  370.,  371.,  372.,  385.,  386.,  387.,  388.,
      393.,  394.,  395.,  396.,  545.,  546.,  547.,  548.,  561.,  562.,
      563.,  564.,  569.,  570.,  571.,  572.,  589.,  590.,  591.,  592.,
      605.,  606.,  607.,  608.,  613.,  614.,  615.,  616.,  809.,  810.,
      811.,  812.,  825.,  826.,  827.,  828.,  833.,  834.,  835.,  836.,
      985.,  986.,  987.,  988.,  1001., 1002., 1003., 1004., 1009., 1010.,
      1011., 1012., 1161., 1162., 1163., 1164., 1177., 1178., 1179., 1180.,
      1185., 1186., 1187., 1188., 1205., 1206., 1207., 1208., 1221., 1222.,
      1223., 1224., 1229., 1230., 1231., 1232., 1425., 1426., 1427., 1428.,
      1441., 1442., 1443., 1444., 1449., 1450., 1451., 1452., 1601., 1602.,
      1603., 1604., 1617., 1618., 1619., 1620., 1625., 1626., 1627., 1628.,
      1777., 1778., 1779., 1780., 1793., 1794., 1795., 1796., 1801., 1802.,
      1803., 1804., 1821., 1822., 1823., 1824., 1837., 1838., 1839., 1840.,
      1845., 1846., 1847., 1848.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x14x11x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      289.,  290.,  291.,  292.,  305.,  306.,  307.,  308.,  465.,  466.,
      467.,  468.,  481.,  482.,  483.,  484.,  905.,  906.,  907.,  908.,
      921.,  922.,  923.,  924.,  1081., 1082., 1083., 1084., 1097., 1098.,
      1099., 1100., 1521., 1522., 1523., 1524., 1537., 1538., 1539., 1540.,
      1697., 1698., 1699., 1700., 1713., 1714., 1715., 1716.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x14x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      54.,  58.,  60.,  102., 106., 108., 150., 154., 156., 162., 166., 168.,
      222., 226., 228., 270., 274., 276., 318., 322., 324., 330., 334., 336.,
      390., 394., 396., 438., 442., 444., 486., 490., 492., 498., 502., 504.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x14x12x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {79.,  83.,  127., 131., 247., 251.,
                                         295., 299., 415., 419., 463., 467.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x14x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      107., 108., 115.,  116.,  119.,  120., 203., 204., 211., 212., 215.,
      216., 299., 300.,  307.,  308.,  311., 312., 323., 324., 331., 332.,
      335., 336., 443.,  444.,  451.,  452., 455., 456., 539., 540., 547.,
      548., 551., 552.,  635.,  636.,  643., 644., 647., 648., 659., 660.,
      667., 668., 671.,  672.,  779.,  780., 787., 788., 791., 792., 875.,
      876., 883., 884.,  887.,  888.,  971., 972., 979., 980., 983., 984.,
      995., 996., 1003., 1004., 1007., 1008.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x14x12x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      157., 158., 165., 166., 253., 254., 261., 262., 493., 494., 501., 502.,
      589., 590., 597., 598., 829., 830., 837., 838., 925., 926., 933., 934.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x14x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      213.,  214.,  215.,  216.,  229.,  230.,  231.,  232.,  237.,  238.,
      239.,  240.,  405.,  406.,  407.,  408.,  421.,  422.,  423.,  424.,
      429.,  430.,  431.,  432.,  597.,  598.,  599.,  600.,  613.,  614.,
      615.,  616.,  621.,  622.,  623.,  624.,  645.,  646.,  647.,  648.,
      661.,  662.,  663.,  664.,  669.,  670.,  671.,  672.,  885.,  886.,
      887.,  888.,  901.,  902.,  903.,  904.,  909.,  910.,  911.,  912.,
      1077., 1078., 1079., 1080., 1093., 1094., 1095., 1096., 1101., 1102.,
      1103., 1104., 1269., 1270., 1271., 1272., 1285., 1286., 1287., 1288.,
      1293., 1294., 1295., 1296., 1317., 1318., 1319., 1320., 1333., 1334.,
      1335., 1336., 1341., 1342., 1343., 1344., 1557., 1558., 1559., 1560.,
      1573., 1574., 1575., 1576., 1581., 1582., 1583., 1584., 1749., 1750.,
      1751., 1752., 1765., 1766., 1767., 1768., 1773., 1774., 1775., 1776.,
      1941., 1942., 1943., 1944., 1957., 1958., 1959., 1960., 1965., 1966.,
      1967., 1968., 1989., 1990., 1991., 1992., 2005., 2006., 2007., 2008.,
      2013., 2014., 2015., 2016.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x14x12x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      313.,  314.,  315.,  316.,  329.,  330.,  331.,  332.,  505.,  506.,
      507.,  508.,  521.,  522.,  523.,  524.,  985.,  986.,  987.,  988.,
      1001., 1002., 1003., 1004., 1177., 1178., 1179., 1180., 1193., 1194.,
      1195., 1196., 1657., 1658., 1659., 1660., 1673., 1674., 1675., 1676.,
      1849., 1850., 1851., 1852., 1865., 1866., 1867., 1868.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x14x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61.,  65.,  69.,  70.,  117., 121., 125., 126., 173., 177., 181., 182.,
      187., 191., 195., 196., 257., 261., 265., 266., 313., 317., 321., 322.,
      369., 373., 377., 378., 383., 387., 391., 392., 453., 457., 461., 462.,
      509., 513., 517., 518., 565., 569., 573., 574., 579., 583., 587., 588.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x14x14x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.,  95.,  147., 151., 287., 291.,
                                         343., 347., 483., 487., 539., 543.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x14x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121.,  122.,  129.,  130.,  137.,  138.,  139.,  140.,  233.,  234.,
      241.,  242.,  249.,  250.,  251.,  252.,  345.,  346.,  353.,  354.,
      361.,  362.,  363.,  364.,  373.,  374.,  381.,  382.,  389.,  390.,
      391.,  392.,  513.,  514.,  521.,  522.,  529.,  530.,  531.,  532.,
      625.,  626.,  633.,  634.,  641.,  642.,  643.,  644.,  737.,  738.,
      745.,  746.,  753.,  754.,  755.,  756.,  765.,  766.,  773.,  774.,
      781.,  782.,  783.,  784.,  905.,  906.,  913.,  914.,  921.,  922.,
      923.,  924.,  1017., 1018., 1025., 1026., 1033., 1034., 1035., 1036.,
      1129., 1130., 1137., 1138., 1145., 1146., 1147., 1148., 1157., 1158.,
      1165., 1166., 1173., 1174., 1175., 1176.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x14x14x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      181., 182., 189., 190., 293.,  294.,  301.,  302.,
      573., 574., 581., 582., 685.,  686.,  693.,  694.,
      965., 966., 973., 974., 1077., 1078., 1085., 1086.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, SAME3x14x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241.,  242.,  243.,  244.,  257.,  258.,  259.,  260.,  273.,  274.,
      275.,  276.,  277.,  278.,  279.,  280.,  465.,  466.,  467.,  468.,
      481.,  482.,  483.,  484.,  497.,  498.,  499.,  500.,  501.,  502.,
      503.,  504.,  689.,  690.,  691.,  692.,  705.,  706.,  707.,  708.,
      721.,  722.,  723.,  724.,  725.,  726.,  727.,  728.,  745.,  746.,
      747.,  748.,  761.,  762.,  763.,  764.,  777.,  778.,  779.,  780.,
      781.,  782.,  783.,  784.,  1025., 1026., 1027., 1028., 1041., 1042.,
      1043., 1044., 1057., 1058., 1059., 1060., 1061., 1062., 1063., 1064.,
      1249., 1250., 1251., 1252., 1265., 1266., 1267., 1268., 1281., 1282.,
      1283., 1284., 1285., 1286., 1287., 1288., 1473., 1474., 1475., 1476.,
      1489., 1490., 1491., 1492., 1505., 1506., 1507., 1508., 1509., 1510.,
      1511., 1512., 1529., 1530., 1531., 1532., 1545., 1546., 1547., 1548.,
      1561., 1562., 1563., 1564., 1565., 1566., 1567., 1568., 1809., 1810.,
      1811., 1812., 1825., 1826., 1827., 1828., 1841., 1842., 1843., 1844.,
      1845., 1846., 1847., 1848., 2033., 2034., 2035., 2036., 2045., 2046.,
      2047., 2048., 2045., 2046., 2047., 2048., 2013., 2014., 2015., 2016.,
      2033., 2034., 2035., 2036., 2045., 2046., 2047., 2048., 2045., 2046.,
      2047., 2048., 2013., 2014., 2015., 2016., 265.,  266.,  267.,  268.,
      281.,  282.,  283.,  284.,  297.,  298.,  299.,  300.,  301.,  302.,
      303.,  304.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow7Stride4Forward, VALID3x14x14x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      361.,  362.,  363.,  364.,  377.,  378.,  379.,  380.,  585.,  586.,
      587.,  588.,  601.,  602.,  603.,  604.,  1145., 1146., 1147., 1148.,
      1161., 1162., 1163., 1164., 1369., 1370., 1371., 1372., 1385., 1386.,
      1387., 1388., 1929., 1930., 1931., 1932., 1945., 1946., 1947., 1948.,
      2041., 2042., 2043., 2044., 2045., 2046., 2047., 2048.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<7, 4>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
